import { resources, JsonAsset, error } from "cc";

// 使用泛型定义字典类型  
interface Dictionary<T> {  
    [key: string]: T;
} 

export function loadJson(path: string) {
    /**
     * 读取资源文件夹下的文件
    */
    var jsonData: object = null;
    resources.load(path, (err: any, res: JsonAsset) => {
        if (err) {
            error(err.message || err);
            return;
        }
        // 获取到 Json 数据
        // const jsonData: object = res.json;
        // console.log('工作：', jsonData);
        jsonData = res.json;
        console.log('欧拉：', jsonData);
        return jsonData;
    })
    console.log('院士：', jsonData);
}

export function objectDropNull<T>(_object): Dictionary<T> {
    /**
     * 剔除字典中值为null的子元素键值对。
    */
    let _object_ = {}
    if (typeof(_object) === 'object' && _object !== null) {
        for (let key of Object.keys(_object)) {
            if (_object[key] !== null) {
                _object_[key] = _object[key];
            }
        }
    }
    return _object_;
}


export function objectDropZeroLen<T>(_object): Dictionary<T> {
    /**
     * 剔除字典中值的长度为0的子元素键值对。
    */
    let _object_ = {}
    if (typeof(_object) === 'object' && _object !== null) {
        for (let key of Object.keys(_object)) {
            if (_object[key] !== null) {
                if (_object[key].length > 0) {
                    _object_[key] = _object[key];
                }
            }
        }
    }
    return _object_;
}

export function objectLength(_object): number {
    /**
     * 字典长度
    */
    return Object.keys(_object).length;
}


export function shuffleArray<T>(array: T[]): T[] {
    /**
     * 将数组元素随机打乱
    */
    const result = array.slice(); // 创建数组的副本以避免修改原始数组
    const n = result.length;

    for (let i = n - 1; i > 0; i--) {
        // 随机选择一个小于或等于当前索引的索引
        const j = Math.floor(Math.random() * (i + 1));
        // 交换元素
        [result[i], result[j]] = [result[j], result[i]];
    }
    return result;
}


export function getLetterFromASCII(ascii: number): string {
    if (ascii >= 65 && ascii <= 90) {
        // 大写字母的ASCII码范围
        return String.fromCharCode(ascii);
    } else if (ascii >= 97 && ascii <= 122) {
        // 小写字母的ASCII码范围
        return String.fromCharCode(ascii);
    } else {
        throw new Error('Provided ASCII code does not correspond to a letter.');
    }
}

export function isUpperLetter(letter: string): boolean {
    /**
     * 判断输入的值是否为大写字母
    */
    return letter.length && 65 <= letter.charCodeAt(0) && letter.charCodeAt(0) <= 90;
}

export function isLowerLetter(letter: string): boolean {
    /**
     * 判断输入的值是否为小写字母
    */
    return letter.length && 97 <= letter.charCodeAt(0) && letter.charCodeAt(0) <= 122;
}

export function generateUpperCaseLetters(num: number): string[] {
    /**
     * 生成指定数量的大写字母，从A开始
    */
    const letters: string[] = [];
    const start_n: number = 65;
    const stop_n: number = 90;
    if ((num + start_n) <= stop_n) {
        for (let i = 65; i <= (start_n + num); i++) {
            letters.push(String.fromCharCode(i));
        }
    } else {
        throw new Error(`大写字母只有26个哦，您却要${num}个`);
    }
    return letters;
} 

export function camelToSnakeCase(str: string): string {  
    /**
     * 将驼峰命名法的变量转换成下划线命名
    */
    let result = '';  
    for (let i = 0; i < str.length; i++) {  
        if (isUpperLetter(str[i])) {
            if (i===0) {
                result += str[i].toLowerCase();
            } else {
                result += `_${str[i].toLowerCase()}`;
            }
        } else {
            result += str[i];
        }
    }  
    return result;  
}